/**
 * 报表展示的模型； 用于mapp系统的报表展示，配合后台的 com.ai.mapp.model.table.ReportTableModel 使用； 功能：
 * 1. 支持任意层的表头； 2. 支持数据展示；
 * 
 * @author 余根宁
 * @version 1.0
 * @date 2011.5.19
 */
(function($) {

    $.addGrid = function(t, p) {
        // 参数初始化
        var p = $.extend({
            reportTitle : "", // 报表的title
            query : false, // 报表是否查询
            rowcnt : 0, // 显示的列；
            reportId : "", // 报表ID
            tableHeaders : false, // 表头信息 数组形式
            reportData : false, // 报表数据 数组形式
            onThresholdCellClick : false, // /标杆列单击事件
            onMetricSelect : false, // /指标筛选的单击事件；
            onOperatorClick : false, // / 操作列处理；
            onSelectClick : false,// /过滤选择框选择事件；
            onDownClick : false, // / 下载按钮处理
            whereCondition : "", // where 条件
            headFixed : false, // /表头列固定
            sortable : true,// /表头排序
            dimUrl : "", // 钻取的url
            lastsort : "", // 上次排序列
            sortorder : "", // 排序类型
            maxcnt : 500
                // 显示最大记录数 500 条
            }, p);

        var browserName = navigator.appName;// 获取浏览器信息,用于后面代码区分浏览器
        var ver = navigator.appVersion;
        var browserVersion = parseFloat(ver.substring(ver.indexOf("MSIE") + 5, ver.lastIndexOf("Windows")));

        var g = {
            fieldInfo : {}, // /所有的列信息，采用 fieldName : field 的处理方式；
            leafField : [], // /所有的叶子列，即可用于显示数据的列；
            dimField : "", // /可穿透的Field; 目前仅支持一个字段；
            queryField : [], // /可做查询条件的Field;支持多个字段；
            rowData : [], // 数据
            whereConditions : {}, // /where 条件信息；
            totalData : [], // /统计数据
            bodyData:[], ///实际展示的数据
            // /数据
            addData : function(data) {
                this.rowData = data;// 数据
                this.populate(data);
            },
            populate : function(data) {
                $("tbody", t).remove();
                this.bodyData  = data;
                var tbody = document.createElement("tbody");
                $(t).append(tbody);
                if (!$.isArray(data) || data.length == 0) {
                    return;
                }

                for (var i = 0; i < data.length; i++) {
                    var row = data[i];
                    var tr = document.createElement("tr");
                    $(tr).attr("row", i);
                    tr.id = "row-list";
                    for (var j = 0; j < this.leafField.length; j++) {
                        var col = this.fieldInfo[this.leafField[j]];
                        if (col.displayStatus == '0') { // /如果显示，那么显示；否则不显示；
                            var cell = row[col.name] == undefined || row[col.name] == "null" ? "" : row[col.name];
                            // 加列
                            var td = this.addCell(col, cell);
                            $(tr).append(td);
                            td = null;
                            cell = null;
                        }
                    }
                    $(tbody).append(tr);
                    tr = null;

                    // /显示数据行：5行；
                    if (p.rowcnt > 0 && i == p.rowcnt - 1) {
                        break;
                    }
                }
            },
            /**
             * 对原有数据进行筛选显示；
             * 
             * @param filter
             *            筛选条件； filter.col 筛选列； filter.value 筛选值；
             */
            filterDataPopulate : function(filter) {
                try {
                    this.loding(t);
                    var params = $.extend({
                                col : "",
                                value : ""
                            }, filter);
                    var tmpData = [];
                    if (params.col == "" || params.value == "") {
                        // 不做过滤
                        tmpData = this.rowData;
                    } else {
                        // 过滤条件增加数据
                        $.each(this.rowData, function(i, n) {
                                    var colValue = n[params.col];
                                    if (colValue.colDimCode == params.value) {
                                        tmpData.push(n);
                                    }
                                })
                    }
                    this.populate(tmpData);
                    if (this.totalData) {
                        this.addTotal(this.totalData);
                    }
                } finally {
                    this.lodeEnd(t);
                }
            },
            /**
             * 排序
             */
            sortDataPopulate : function(sort) {
                try {
                    this.loding(t);
                    var params = $.extend({
                                col : "",
                                sort : ""
                            }, sort);

                    if (p.lastsort == params.col) {
                        if (p.sortorder == 'asc') {
                            p.sortorder = 'desc';
                        } else if (p.sortorder == 'desc') {
                            p.sortorder = 'asc';
                        }
                    } else {
                        p.sortorder = 'asc';
                    }

                    var thd = $("thead", t)[0];
                    $("tr th[colname='" + p.lastsort + "'] span.ui-grid-ico-sort", thd).addClass('ui-state-disabled');
                    // $("tr
                    // th[colname='"+p.lastsort+"']",thd).attr("aria-selected","false");
                    $("tr th[colname='" + params.col + "'] span.ui-icon-" + p.sortorder, thd)
                            .removeClass('ui-state-disabled');
                    // $("tr
                    // th[colname='"+params.col+"']",thd).attr("aria-selected","true");
                    if (p.lastsort != params.col) {
                        $("tr th[colname='" + p.lastsort + "'] span.s-ico", thd).hide();
                        $("tr th[colname='" + params.col + "'] span.s-ico", thd).show();
                    }

                    var tmpData = this._doSortData(this.rowData, params.col, p.sortorder);

                    this.populate(tmpData);
                    if (this.totalData) {
                        this.addTotal(this.totalData);
                    }
                    p.lastsort = params.col;

                } finally {
                    this.lodeEnd(t);
                }
            },
            reloadData : function(opt) {
                try {
                    this.loding(t);
                    var params = $.extend({
                                rowcnt : "0"
                            }, opt);
                    if (params.rowcnt > dataLen) {
                        params.rowcnt = dataLen;
                    }
                    p.rowcnt = params.rowcnt;
                    this.populate(this.rowData);
                    if (this.totalData) {
                        this.addTotal(this.totalData);
                    }
                    $(".span-local-cnt", g.tDiv).text(p.rowcnt);
                } finally {
                    this.lodeEnd(t);
                }
            },
            addCell : function(col, cell) {

                /**
                 * 维度列处理
                 */
                var addDimenCell = function(col, cell) {
                    var td = document.createElement("td");
                    try {
                        $(td).attr("field", col.name);
                        var value = cell == "" || !cell.colValue || cell.colValue == "null" ? "" : cell.colValue;
                        var spanclass = !cell.drillURL || cell.drillURL == "null" ? "" : "dimurl";
                        var span = document.createElement("span");
                        if (spanclass != "") {
                            var opInfo = null;
                            try {
                                opInfo = eval("(" + cell.drillURL + ")");
                            } catch (e) {
                                return td;
                            }
                            $(span).append(g.addLink(opInfo, value));
                        } else {
                            $(span).append(value);
                        }
                        $(td).append(span).addClass("dimcol").addClass(spanclass);
                        return td;
                    } finally {
                        td = null;
                    }
                }
                /**
                 * 指标列处理
                 */
                var addMetricCell = function(col, cell) {
                    var td = document.createElement("td");
                    try {
                        $(td).attr("field", col.name).addClass("metricol");
                        var value = cell == "" || !cell.colValue || cell.colValue == "null" ? "" : cell.colValue;
                        var spanclass = !cell.alarmed ? "metric" : "alarm";
                        var span = document.createElement("span");
                        try {
                            var opInfo = eval("(" + cell.drillURL + ")");
                            $(span).append(g.addLink(opInfo, value));
                        } catch (e) {
                            span.innerHTML = value;
                        }
                        $(span).addClass(spanclass).appendTo(td);
                        // $(td).append(span);
                        if (cell.alarmed) {
                            var imageSpan = document.createElement("span");
                            $(imageSpan).addClass("alarmGif").show();
                            $(td).append(imageSpan);
                            imageSpan = null;
                        }
                        return td;
                    } finally {
                        td = null;
                    }
                }
                /**
                 * 标杆列处理
                 */
                var addThresholdCell = function(col, cell) {
                    var td = document.createElement("td");
                    try {
                        $(td).attr("field", col.name);
                        var value = cell == "" || !cell.colValue || cell.colValue == "null" ? "" : cell.colValue;
                        td.innerHTML = "<span class ='threshold'>" + value + "</span>";
                        $(td).addClass("threcol");
                        var imageSpan = document.createElement("span");
                        try {
                            $(imageSpan).addClass("thresholdImage"); // 行，列
                            $(imageSpan).hide();
                            // 标杆后面的图标单击
                            if (p.onThresholdCellClick && $.isFunction(p.onThresholdCellClick)) {
                                $(imageSpan).click(function(e) {
                                            var td = $(this).parent();
                                            var tr = $(td).parent();
                                            var row = g.bodyData[$(tr).attr("row")];
                                            var dimValue = g.getRowDimFielValue(row);
                                            var cell = $(td).attr("field");
                                            var field = g.fieldInfo[cell];
                                            var position = $(this).offset();
                                            p.onThresholdCellClick({
                                                        "top" : position.top + $(this).height(),
                                                        "left" : position.left,
                                                        "ptColId" : field.ptColId,
                                                        "value" : row[cell].colValue,
                                                        "dimValue" : dimValue
                                                    });
                                        });
                            };

                            $(td).append(imageSpan).mouseover(function(e) {
                                        $("span.thresholdImage", this).show();
                                    }).mouseout(function(e) {
                                        $("span.thresholdImage", this).hide();
                                    });
                        } finally {
                            imageSpan = null;
                        }
                        return td;
                    } finally {
                        td = null;
                    }
                }

                /**
                 * 操作列处理
                 */
                var addOperatorCell = function(col, cell) {
                    var td = document.createElement("td");
                    try {
                        $(td).attr("field", col.name).addClass("operatorcol").append(g.addOperatorCol(cell.drillURL));
                        return td;
                    } finally {
                        td = null;
                    }
                }
                /*
                 * 普通列处理
                 */
                var addCustomCell = function(col, cell) {
                    var td = document.createElement("td");
                    try {
                        $(td).attr("field", col.name);
                        var value = cell == "" || !cell.colValue || cell.colValue == "null" ? "" : cell.colValue;
                        td.innerHTML = "<span>" + value + "</span>";
                        return td;
                    } finally {
                        td = null;
                    }
                }

                var colClass = col.colClass;
                if (colClass == "1") {
                    return addDimenCell(col, cell);
                } else if (colClass == "2") {
                    return addMetricCell(col, cell);
                } else if (colClass == "3") {
                    return addThresholdCell(col, cell);
                } else if (colClass == "4") {
                    return addOperatorCell(col, cell);
                } else {
                    return addCustomCell(col, cell);
                }
            },

            appendField : function(field) {
                this.fieldInfo[field.name] = field;
            },

            getRowDimFielValue : function(row) {
                // /获取该行的dimField值；
                var dimField = row[this.dimField];
                var dimValue = "";
                if (dimField) {
                    dimValue = dimField.colDimCode == undefined || dimField.colDimCode == "null"
                            ? ""
                            : dimField.colDimCode;
                } else {
                    dimValue = "";
                }
                dimField = null;
                return dimValue;
            },

            /**
             * 增加查询条件，以及指标筛选
             */
            addQuery : function() {
                // 针对根节点开始设定 查询下拉框
                $.each(g.leafField, function(i, n) {
                            var col = g.fieldInfo[n];
                            // 获取格式化
                            var s = !col.formate || col.formate == "null" ? "" : col.formate;
                            var format = {};
                            try {
                                format = eval("(" + s + ")");
                            } catch (e) {
                                format = {};
                            }
                            // /维度列，而且是可以查询的，格式化中有字典的。才能够作为查询使用
                            if (col && col.colClass == '1' && col.query && format && format.dict) {
                                // /可以做为查询条件；而且有定义字典名称；
                                var span = g.addSelect(col, format);
                                $(g.sDiv).append("<span>|</span>").append(span);
                            }
                        });
            },
            /**
             * 指标筛选
             */
            addMetricSelect : function() {
                // /增加指标筛选行
                if (p.onMetricSelect && $.isFunction(p.onMetricSelect)) {
                    var span = document.createElement("span");
                    try {
                        span.id = "userField";
                        span.innerHTML = "【指标筛选】";
                        $(span).addClass("metricSelect").bind("click", function() {
                                    var position = $(this).offset();
                                    p.onMetricSelect({
                                                "top" : position.top + $(this).height(),
                                                "left" : position.left + 20
                                            });

                                });
                        $(g.sDiv).append(span);
                    } finally {
                        span = null;
                    }

                }
            },
            /**
             * 增加下拉选择框；
             * 
             * @param field
             *            信息
             * @param format
             *            格式化信息 {type:"",dict:"",defvalue:""}
             */
            addSelect : function(field, format, parentId) {
                var dict = format.dict;
                var type = format.type;
                var span = document.createElement("span");
                $(span).text(field.label + ":");
                var select = document.createElement("select");
                $(select).attr("id", field.name).addClass("edit");
                if (type == "string") {
                    // 下拉选择修改事件；外部确定；
                    if (p.onSelectClick && $.isFunction(p.onSelectClick)) {
                        $(select).bind("change", function(e) {
                                    p.onSelectClick({
                                                id : $(this).attr("id"),
                                                value : $(this).val()
                                            })
                                });
                    }
                } else {
                    // 如果是其它的，表示数据过滤。内部处理
                    $(select).bind("change", function(e) {
                                $(t).filterData({
                                            col : $(this).attr("id"),
                                            value : $(this).val()
                                        })
                            });
                }

                // /调用frameajax.js 的 构造 select 下拉框的方法；
                var param = [{
                            name : "dictName",
                            value : dict
                        }];
                if (parentId) {
                    param.push({
                                name : "parentId",
                                value : parentId
                            });
                }
                /**
                 * 增加到对应的信息中
                 */
                $.fillSelect({
                            select : "#" + field.name,
                            url : p.dimUrl+'sys/dict!listDictItem.action',
                            data : param,
                            isBlank : true,
                            onResultData : function(data) {
                                var fieldvalue = g.whereConditions[field.name];
                                if (!fieldvalue || fieldvalue == "") {
                                    // // 不处理；过滤值取 默认值
                                    fieldvalue = format.defvalue;
                                }
                                $.each(data.options, function(i, n) {
                                            if (n.value == fieldvalue) {
                                                n.selected = true;
                                            }
                                        })
                                return data;
                            },
                            callback : function() {
                                // /处理成功之后的回调函数
                                /*
                                 * if (format.defvalue && format.defvalue != "") {
                                 * var fieldvalue =
                                 * g.whereConditions[field.name]; if
                                 * (!fieldvalue || fieldvalue == "") { //
                                 * /如果有默认值，而且where条件中的该列没有值，那么表示是第一次设置，需要重新过滤数据
                                 * $(select).change(); } }
                                 */
                            }
                        });
                $(span).append(select);
                return span;
            },
            /**
             * 获取where条件中对应字段信息的内容
             */
            addWhereConditions : function(data) {
                this.whereConditions = {};
                var infos = data.split("AND");
                $.each(infos, function(i, n) {
                            var datas = n.split("=");
                            if (datas.length >= 2) {
                                var fieldId = $.trim(datas[0]);
                                // 过滤 [] ;
                                fieldId = fieldId.replace("[", "").replace("]", "");
                                var value = $.trim(datas[1]);
                                value = value.replace(/'/g, "");
                                if (fieldId == "" || value == "") {
                                    // /如果字段名称 和 值不为空，那么需要写入；
                                } else {
                                    g.whereConditions[fieldId] = value;
                                }
                            }
                        })
            },
            addOperatorCol : function(operator) {
                var span = document.createElement("span");
                var opInfos = operator.split("|");
                $.each(opInfos, function(i, n) {
                            var opInfo = null;
                            try {
                                opInfo = eval("(" + n + ")");
                            } catch (e) {
                                return;
                            }
                            var value = "";
                            if (opInfo.name) {
                                value = opInfo.name;
                            } else {
                                value = "操作" + i;
                            }

                            if (i > 0) {
                                $(span).append("|");
                            }
                            $(span).append(g.addLink(opInfo, value));

                        });
                return span;
            },

            addLink : function(opInfo, value) {
                var alink = document.createElement("a");
                try {
                    alink.href = "javascript:void(0)";
                    alink.innerHTML = value;
                    $(alink).bind("click", opInfo, function(e) {
                                if (p.onOperatorClick && $.isFunction(p.onOperatorClick)) {
                                    p.onOperatorClick(e.data);
                                }
                                return false;
                            });
                    return alink;
                } finally {
                    alink = null;
                }
            },

            addTotal : function(total) {
                if (!$.isArray(total) && total.length == 0) {
                    return;
                }
                this.totalData = total;
                var tr = document.createElement("tr");
                var first_dim = false;
                for (var j = 0; j < g.leafField.length; j++) {
                    var col = g.fieldInfo[g.leafField[j]];
                    if (col.displayStatus == '0') { // /如果显示，那么显示；否则不显示；
                        // 加列
                        var cell = !total || total[col.name] == undefined || total[col.name] == "null"
                                ? ""
                                : total[col.name];
                        var value = "";
                        var tdclass = "";
                        if (col.colClass == "1") {
                            if (first_dim) {
                                value = "-";
                            } else {
                                value = "合计";
                                first_dim = true;
                            }
                            tdclass = "dimcol";
                        } else if (col.colClass == "3") {
                            // value = "-"; // /标杆列合计值不显示；
                            value = cell == "" || !cell.colValue || cell.colValue == "null" ? "" : cell.colValue;
                            tdclass = "threcol";
                        } else if (col.colClass == "4") {
                            value = "-"; // /操作列不显示；
                            tdclass = "operatorcol";
                        } else {
                            value = cell == "" || !cell.colValue || cell.colValue == "null" ? "" : cell.colValue;
                            tdclass = "metricol";
                        }
                        var td = document.createElement("td");
                        $(td).append("<span>" + value + "</span>").addClass(tdclass);
                        $(tr).append(td);
                        td = null;
                    }
                }
                $(tr).addClass("total");
                $("tbody:last", t).append(tr);
            },

            addDimInfo : function(dimInfo) {
                $(g.dimDiv).append("<span>钻取级别</span>");
            },
            /**
             * 钻取
             */
            addDownInfo : function(data) {
                var span = document.createElement("span");
                $(span).append("【报表下载】").addClass("report-downreport");
                var info = {};
                $(span).bind("click", info, function(e) {
                            if (p.onDownClick && $.isFunction(p.onDownClick)) {
                                p.onDownClick(e.data);
                            }
                        });
                // 报表数据下载；
                $(g.sDiv).append(span);
            },

            addHeader : function(tableHeaders) {
                var thead = document.createElement('thead');

                for (var i = 0; i < p.tableHeaders.length; i++) {
                    var tr = document.createElement("tr");
                    var row = p.tableHeaders[i];
                    for (var j = 0; j < row.length; j++) {
                        var cell = row[j];
                        var th = document.createElement("th");
                        // th.innerHTML = "<span id='thdiv_" + cell.name + "'>"
                        // + cell.label + "</span>";
                        th.innerHTML = cell.label;
                        $(th).addClass("label").attr("role", 'columnheader').attr("id", 'col_' + cell.name).attr(
                                "colname", cell.name).attr("isLeaf", cell.leaf).attr("isQuery", cell.query);
                        if (cell.title) {
                            $(th).attr("title", cell.title);
                        };
                        if (cell.rowspan) {
                            $(th).attr("rowspan", cell.rowspan);
                        };
                        if (cell.colspan) {
                            $(th).attr("colspan", cell.colspan);
                        };
                        if (cell.displayStatus == '0') {
                            $(th).show();
                        } else {
                            $(th).hide();
                        }
                        $(tr).append(th);
                        th = null;
                        // 增加到列中
                        g.appendField(cell);
                    }

                    $(thead).append(tr);
                    tr = null;
                }
                return thead;
            },

            fixTableHeader : function(tableId) {
                var content = g.bDiv;
                var scrollWidth = content.offsetWidth - content.clientWidth;
                var tableOrg = jQuery("#" + tableId);// 获取表内容
                var table = tableOrg.clone();// 克隆表内容
                table.attr("id", "cloneTable");
                // 注意:需要将要冻结的表头放入thead中
                var tableHeader = jQuery(tableOrg).find("thead");
                var tableHeaderHeight = tableHeader.height();
                // //取表头的列宽度
                var colsWidths = jQuery(tableOrg).find("thead tr th[isLeaf='true']:visible").map(function() {
                            return jQuery(this).width();
                        });// 动态获取每一列的宽度

                var tableCloneCols = jQuery(table).find("tbody tr:first td");
                if (colsWidths.size() > 0) {// 根据浏览器为冻结的表头宽度赋值(主要是区分IE8)
                    for (var i = 0; i < tableCloneCols.size(); i++) {
                        if (i == tableCloneCols.size() - 1) {
                            if (browserVersion == 8.0)
                                tableCloneCols.eq(i).width(colsWidths[i] + scrollWidth);
                            else
                                tableCloneCols.eq(i).width(colsWidths[i]);
                        } else {
                            tableCloneCols.eq(i).width(colsWidths[i]);
                        }
                    }
                }

                // 创建冻结表头的DIV容器,并设置属性
                var headerDiv = g.hDiv;
                headerDiv.appendChild(table[0]);
                jQuery(headerDiv).css("height", tableHeaderHeight);
                jQuery(headerDiv).css("overflow", "hidden");
                jQuery(headerDiv).css("z-index", "20");
                jQuery(headerDiv).css("width", $(tableOrg).width());
                jQuery(headerDiv).attr("id", "tableHeaderDiv" + tableId);
                // jQuery(headerDiv).insertBefore(tableOrg.parent());
                // tableHeader.hide();
            },

            loding : function(t) {
                $(t).block({
                            message : "加载中......"
                        });
            },

            lodeEnd : function(t) {
                $(t).unblock();
            },

            /**
             * 对数据进行排序；
             * 
             * @param data
             *            待排序的数据；g.rowData;
             * @param fieldName
             *            排序列；
             * @sortType 排序规则
             */
            _doSortData : function(data, fieldName, sortType) {
                // /需要需要排序的字段为 空，那么不进行排序；
                if (!fieldName || fieldName == "") {
                    return data;
                }
                // 排序类型； a：升序； b: 降序
                var _sort = sortType == "asc" ? 1 : -1;
                var _sortData = [];
                var sortData = [];
                $.each(data, function(i, n) {
                            var value = n[fieldName].colDimCode;
                            _sortData.push({
                                        'vSort' : value,
                                        'index' : i
                                    });
                        });

                _sortData.sort(function(a, b) {
                            a = a.vSort;
                            b = b.vSort;
                            return g._compare(a, b, _sort);
                        });

                var j = 0;
                var nrec = data.length;
                // overhead, but we do not change the original data.
                while (j < nrec) {
                    var i = _sortData[j].index;
                    sortData.push(data[i]);
                    j++;
                }

                return sortData;
            },
            /**
             * @param d
             *            排列顺序 1 升序；-1 降序；
             */
            _compare : function(a, b, d) {
                var getRealNumber = function(a) {
                    // /空，或者非数字，不参数排序
                    var tmp = 0;
                    if (a === undefined || a == "") {
                        tmp = -Number.MAX_VALUE;
                    } else {
                        try {
                            tmp = parseFloat(a)
                        } catch (err) {
                            tmp = -Number.MAX_VALUE;
                        }
                    }

                    if (tmp == -Number.MAX_VALUE) {
                        if (d == -1) {
                            // 降序 返回最小值
                            return -Number.MAX_VALUE;
                        } else {
                            // 升序
                            return Number.MAX_VALUE;
                        }
                    } else {
                        return tmp;
                    }
                }

                if (d === undefined || d == "") {
                    d = 1;
                }
                var tmpa = getRealNumber(a);
                var tmpb = getRealNumber(b);
                if (tmpa < tmpb) {
                    // 升序 返回 -1 ，降序返回 1；
                    return -d;
                }
                if (tmpa > tmpb) {
                    return d;
                }
                return 0;
            }
        };

        // init divs
        g.gDiv = document.createElement('div'); // create global container
        g.dimDiv = document.createElement('div'); // create dim container
        g.hDiv = document.createElement('div'); // create header container
        g.bDiv = document.createElement('div'); // create body container 数据
        g.sDiv = document.createElement('div'); // create 查询，下载
        // g.vDiv = document.createElement('div'); // create grip
        // g.rDiv = document.createElement('div'); // create horizontal resizer
        g.tDiv = document.createElement('div'); // create toolbar

        // 把where条件设置到 g 中；
        g.addWhereConditions(p.whereCondition);

        // 表头处理，同时获取相应的一些显示列信息；
        if (p.tableHeaders) {
            var thead = g.addHeader(p.tableHeaders);
            /*
             * var hTable = document.createElement("table");
             * $(hTable).append(thead).addClass("reportBox");
             * $(g.hDiv).append(hTable);
             */
            $(t).append(thead);
        }
        if (p.sortable) {
            var imgs = "<span class='s-ico' style='display:none'>";
            imgs += "<span sort='asc' class='ui-grid-ico-sort ui-icon-asc ui-state-disabled ui-icon ui-icon-triangle-1-n '></span>";
            imgs += "<span sort='desc' class='ui-grid-ico-sort ui-icon-desc ui-state-disabled ui-icon ui-icon-triangle-1-s '></span>";
            imgs += "</span>";
            // .addClass("ui-jqgrid-sortable")
            $("thead>tr>th[isLeaf='true']", t).each(function(j) {
                        var fieldname = $(this).attr("colname");
                        var col = g.fieldInfo[fieldname];
                        if (col.colClass != "1") {
                            // /不是维度列；维度列不参与排序
                            $(this).append(imgs).addClass("ui-jqgrid-sortable").click(function(e) {
                                        // alert("排序");
                                        $(t).sortData({
                                                    col : $(this).attr("colname"),
                                                    sort : "asc"
                                                })
                                    });
                        }
                    })
        }
        /**
         * 将叶子Field 写入 g.leafField； 同时处理相关的 比如查询条件列，钻取列的信息；
         */
        var getLeafField = function(header, rowcnt, pid) {
            var row = header[rowcnt];
            // var leaf = [];
            if (row) {
                for (var i = 0; i < row.length; i++) {
                    var cell = row[i];
                    // / 当前节点的是父节点
                    if (cell.parentHeaderId == pid) {
                        if (cell.leaf) {
                            g.leafField.push(cell.name);
                            // /维度列
                            if (cell.colClass == "1") {
                                // 可查询，那么作为查询条件列；
                                if (cell.query) {
                                    g.queryField.push[cell.name];
                                }
                                // 可钻取，作为钻取列；目前仅支持一个钻取列；
                                if (cell.drillable) {
                                    g.dimField = cell.name;
                                }
                            }
                        } else {
                            // 非叶子节点，获取下属的子节点中叶子节点；
                            getLeafField(header, rowcnt + 1, cell.headerId);
                        }
                    }
                }
            }
        }

        // //获取叶子列
        if (p.tableHeaders) {
            getLeafField(p.tableHeaders, 0, "0");
        }

        // 报表数据
        if (p.reportData) {
            // 显示数据超过记录数，需要控制
            var dataLen = p.reportData.length;
            var cnt = p.maxcnt;
            if (dataLen > cnt) {
                // /超过500条记录，需要提醒
                var span = document.createElement("span");
                try {
                    span.id = "span-len-message";
                    if (p.rowcnt > 0) {
                        cnt = p.rowcnt;
                    } else {
                        p.rowcnt = cnt;
                    }
                    var message = "报表的数据合计：<span class='span-max-cnt'>" + dataLen
                            + "</span>条；目前显示<span class='span-local-cnt'>" + cnt
                            + "</span>条记录。需要显示更多数据，请输入需要显示的行数并点确定。";
                    var input = "<input type='edit' class='edit w50' id='report-data-redmine-info' name='report-data-redmine-info' value='"
                            + cnt + "'></input>";
                    var button = "<input type='button' class='w50' id='btn-report-data-redmine' value='确定'/>";
                    $(span).addClass("span-redmine-messge").append(message).appendTo(g.tDiv);
                    $(g.tDiv).append(input).append(button);
                    $(":button", g.tDiv).click(function(e) {
                                var cnt = $(this).siblings(":text").val();
                                $(t).reloadData({
                                            rowcnt : cnt
                                        });
                            });
                } finally {
                    span = null;
                }
            }
            g.addData(p.reportData);
        }

        // 在table外层嵌入一个div;
        $(t).addClass("reportBox").before(g.gDiv);
        $(g.gDiv).addClass("report-top-div").append(g.tDiv).append(g.dimDiv).append(g.sDiv).append(g.hDiv)
                .append(g.bDiv);
        $(g.bDiv).append(t);
        
        alert($(g.gDiv).innerWidth());

        // end 表头；

        // /如果报表有查询列，那么如下；
        if (p.query) {
            $(g.sDiv).addClass("list");
            // 指标筛选
            g.addMetricSelect();
            // /下载链接
            g.addDownInfo();
            // /增加报表查询条件 ，以及指标筛选条件
            g.addQuery();
            // g.addDimInfo();

        }
        // 增加合计行
        if (p.total && p.totalData) {
            g.addTotal(p.totalData);
        }

        // /表头固定

        t.grid = g;
        t.p = p;

        /*
         * if(p.headFixed){ g.fixTableHeader(t.id); }
         */
        return t;
    }

    /**
     * reportGrid 的入口函数
     */
    $.fn.reportGrid = function(p) {
        return this.each(function() {
                    /*
                     * if (!docloaded) { $(this).hide(); var t = this;
                     * $(document).ready(function () { $.addGrid(t, p); }); }
                     * else { $.addGrid(this, p); }
                     */
                    $.addGrid(this, p);
                });
    }

    /**
     * 过滤信息
     */
    $.fn.filterData = function(filter) {
        return this.each(function() {
                    if (this.grid)
                        this.grid.filterDataPopulate(filter);
                });
    }

    /**
     * 排序
     * 
     * @sort.col 排序列
     * @sort.sort 排序条件； a:升序；d:降序
     */
    $.fn.sortData = function(sort) {
        return this.each(function() {
                    if (this.grid)
                        this.grid.sortDataPopulate(sort);
                });
    }

    $.fn.reloadData = function(opt) {
        return this.each(function() {
                    if (this.grid) {
                        this.grid.reloadData(opt);
                    }
                })
    }

})(jQuery)